{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 机器学习练习-决策树\n",
    "\n",
    "实验要求：1，请将本实验中两处代码不完整的地方补充完整：2，如果出现graphviz问题，请尝试解决；3，对照本章ppt和本实验代码，理解决策树原理。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1．分类决策树模型是表示基于特征对实例进行分类的树形结构。决策树可以转换成一个**if-then**规则的集合，也可以看作是定义在特征空间划分上的类的条件概率分布。\n",
    "\n",
    "2．决策树学习旨在构建一个与训练数据拟合很好，并且复杂度小的决策树。因为从可能的决策树中直接选取最优决策树是NP完全问题。现实中采用启发式方法学习次优的决策树。\n",
    "\n",
    "决策树学习算法包括3部分：特征选择、树的生成和树的剪枝。常用的算法有ID3、\n",
    "C4.5和CART。\n",
    "\n",
    "3．特征选择的目的在于选取对训练数据能够分类的特征。特征选择的关键是其准则。常用的准则如下：\n",
    "\n",
    "（1）样本集合$D$对特征$A$的信息增益（ID3）\n",
    "\n",
    "\n",
    "$$g(D, A)=H(D)-H(D|A)$$\n",
    "\n",
    "$$H(D)=-\\sum_{k=1}^{K} \\frac{\\left|C_{k}\\right|}{|D|} \\log _{2} \\frac{\\left|C_{k}\\right|}{|D|}$$\n",
    "\n",
    "$$H(D | A)=\\sum_{i=1}^{n} \\frac{\\left|D_{i}\\right|}{|D|} H\\left(D_{i}\\right)$$\n",
    "\n",
    "其中，$H(D)$是数据集$D$的熵，$H(D_i)$是数据集$D_i$的熵，$H(D|A)$是数据集$D$对特征$A$的条件熵。\t$D_i$是$D$中特征$A$取第$i$个值的样本子集，$C_k$是$D$中属于第$k$类的样本子集。$n$是特征$A$取 值的个数，$K$是类的个数。\n",
    "\n",
    "（2）样本集合$D$对特征$A$的信息增益比（C4.5）\n",
    "\n",
    "\n",
    "$$g_{R}(D, A)=\\frac{g(D, A)}{H(D)}$$\n",
    "\n",
    "\n",
    "其中，$g(D,A)$是信息增益，$H(D)$是数据集$D$的熵。\n",
    "\n",
    "（3）样本集合$D$的基尼指数（CART）\n",
    "\n",
    "$$\\operatorname{Gini}(D)=1-\\sum_{k=1}^{K}\\left(\\frac{\\left|C_{k}\\right|}{|D|}\\right)^{2}$$\n",
    "\n",
    "特征$A$条件下集合$D$的基尼指数：\n",
    "\n",
    " $$\\operatorname{Gini}(D, A)=\\frac{\\left|D_{1}\\right|}{|D|} \\operatorname{Gini}\\left(D_{1}\\right)+\\frac{\\left|D_{2}\\right|}{|D|} \\operatorname{Gini}\\left(D_{2}\\right)$$\n",
    " \n",
    "4．决策树的生成。通常使用信息增益最大、信息增益比最大或基尼指数最小作为特征选择的准则。决策树的生成往往通过计算信息增益或其他指标，从根结点开始，递归地产生决策树。这相当于用信息增益或其他准则不断地选取局部最优的特征，或将训练集分割为能够基本正确分类的子集。\n",
    "\n",
    "5．决策树的剪枝。由于生成的决策树存在过拟合问题，需要对它进行剪枝，以简化学到的决策树。决策树的剪枝，往往从已生成的树上剪掉一些叶结点或叶结点以上的子树，并将其父结点或根结点作为新的叶结点，从而简化生成的决策树。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "from math import log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 创建数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_data():\n",
    "    datasets = [['青年', '否', '否', '一般', '否'],\n",
    "               ['青年', '否', '否', '好', '否'],\n",
    "               ['青年', '是', '否', '好', '是'],\n",
    "               ['青年', '是', '是', '一般', '是'],\n",
    "               ['青年', '否', '否', '一般', '否'],\n",
    "               ['中年', '否', '否', '一般', '否'],\n",
    "               ['中年', '否', '否', '好', '否'],\n",
    "               ['中年', '是', '是', '好', '是'],\n",
    "               ['中年', '否', '是', '非常好', '是'],\n",
    "               ['中年', '否', '是', '非常好', '是'],\n",
    "               ['老年', '否', '是', '非常好', '是'],\n",
    "               ['老年', '否', '是', '好', '是'],\n",
    "               ['老年', '是', '否', '好', '是'],\n",
    "               ['老年', '是', '否', '非常好', '是'],\n",
    "               ['老年', '否', '否', '一般', '否'],\n",
    "               ]\n",
    "    labels = [u'年龄', u'有工作', u'有自己的房子', u'信贷情况', u'类别']\n",
    "    # 返回数据集和每个维度的名称\n",
    "    return datasets, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets, labels = create_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
   "train_data = pd.DataFrame(datasets, columns=labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>年龄</th>\n",
       "      <th>有工作</th>\n",
       "      <th>有自己的房子</th>\n",
       "      <th>信贷情况</th>\n",
       "      <th>类别</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>青年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>青年</td>\n",
       "      <td>是</td>\n",
       "      <td>是</td>\n",
       "      <td>一般</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>中年</td>\n",
       "      <td>是</td>\n",
       "      <td>是</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>老年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>老年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    年龄 有工作 有自己的房子 信贷情况 类别\n",
       "0   青年   否      否   一般  否\n",
       "1   青年   否      否    好  否\n",
       "2   青年   是      否    好  是\n",
       "3   青年   是      是   一般  是\n",
       "4   青年   否      否   一般  否\n",
       "5   中年   否      否   一般  否\n",
       "6   中年   否      否    好  否\n",
       "7   中年   是      是    好  是\n",
       "8   中年   否      是  非常好  是\n",
       "9   中年   否      是  非常好  是\n",
       "10  老年   否      是  非常好  是\n",
       "11  老年   否      是    好  是\n",
       "12  老年   是      否    好  是\n",
       "13  老年   是      否  非常好  是\n",
       "14  老年   否      否   一般  否"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 熵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算给定数据集的熵（信息熵）\n",
    "def calc_ent(datasets):\n",
    "    # 计算数据集的长度\n",
    "    data_length = len(datasets)\n",
    "    # 统计数据集中每个类别的出现次数\n",
    "    label_count = {}\n",
    "    for i in range(data_length):\n",
    "        # 获取每个样本的标签\n",
    "        label = datasets[i][-1]\n",
    "        # 如果该类别不在label_count中，则添加到label_count中\n",
    "        if label not in label_count:\n",
    "            label_count[label] = 0\n",
    "        # 统计该类别的出现次数\n",
    "        label_count[label] += 1\n",
    "    # 计算熵\n",
    "    ent = -sum([(p / data_length) * log(p / data_length, 2)\n",
    "                for p in label_count.values()])\n",
    "    return ent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 条件熵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算给定数据集在指定特征上的条件熵\n",
    "def cond_ent(datasets, axis=0):\n",
    "    # 计算数据集的长度\n",
    "    data_length = len(datasets)\n",
    "    # 使用字典feature_sets存储在指定特征上的不同取值对应的样本集合\n",
    "    feature_sets = {}\n",
    "    for i in range(data_length):\n",
    "        # 获取每个样本在指定特征上的取值\n",
    "        feature = datasets[i][axis]\n",
    "        # 如果该取值不在feature_sets中，则添加到feature_sets中\n",
    "        if feature not in feature_sets:\n",
    "            feature_sets[feature] = []\n",
    "        # 将该样本添加到对应取值的样本集合中\n",
    "        feature_sets[feature].append(datasets[i])\n",
    "    # 计算条件熵\n",
    "    cond_ent = sum([(len(p) / data_length) * calc_ent(p)\n",
    "                    for p in feature_sets.values()])\n",
    "    return cond_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9709505944546686"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_ent(datasets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 信息增益"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算信息增益\n",
    "def info_gain(ent, cond_ent):\n",
    "    # 信息增益等于熵减去条件熵\n",
    "    return ent - cond_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用信息增益选择最佳特征作为根节点特征进行决策树的训练\n",
    "def info_gain_train(datasets):\n",
    "    # 计算特征的数量\n",
    "    count = len(datasets[0]) - 1\n",
    "    # 计算整个数据集的熵\n",
    "    ent = calc_ent(datasets)\n",
    "    # 存储每个特征的信息增益\n",
    "    best_feature = []\n",
    "    for c in range(count):\n",
    "        # 计算每个特征的条件熵\n",
    "        c_info_gain = info_gain(ent, cond_ent(datasets, axis=c))\n",
    "        # 将特征及其对应的信息增益存入best_feature列表中\n",
    "        best_feature.append((c, c_info_gain))\n",
    "        # 输出每个特征的信息增益\n",
    "        print('特征({}) 的信息增益为： {:.3f}'.format(labels[c], c_info_gain))\n",
    "    # 找到信息增益最大的特征\n",
    "    best_ = max(best_feature, key=lambda x: x[-1])\n",
    "    # 返回信息增益最大的特征作为根节点特征\n",
    "    return '特征({})的信息增益最大，选择为根节点特征'.format(labels[best_[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征(年龄) 的信息增益为： 0.083\n",
      "特征(有工作) 的信息增益为： 0.324\n",
      "特征(有自己的房子) 的信息增益为： 0.420\n",
      "特征(信贷情况) 的信息增益为： 0.363\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'特征(有自己的房子)的信息增益最大，选择为根节点特征'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "info_gain_train(np.array(datasets))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 利用ID3算法生成决策树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义节点类 二叉树\n",
    "class Node:\n",
    "    def __init__(self, root=True, label=None, feature_name=None, feature=None):\n",
    "        self.root = root\n",
    "        self.label = label\n",
    "        self.feature_name = feature_name\n",
    "        self.feature = feature\n",
    "        self.tree = {}\n",
    "        self.result = {\n",
    "            'label:': self.label,\n",
    "            'feature': self.feature,\n",
    "            'tree': self.tree\n",
    "        }\n",
    "\n",
    "    def __repr__(self):\n",
    "        return '{}'.format(self.result)\n",
    "\n",
    "    def add_node(self, val, node):\n",
    "        self.tree[val] = node\n",
    "\n",
    "    def predict(self, features):\n",
    "        if self.root is True:\n",
    "            return self.label\n",
    "        return self.tree[features[self.feature]].predict(features)\n",
    "\n",
    "\n",
    "class DTree:\n",
    "    def __init__(self, epsilon=0.1):\n",
    "        self.epsilon = epsilon\n",
    "        self._tree = {}\n",
    "\n",
    "    # 熵\n",
    "    @staticmethod\n",
    "    def calc_ent(datasets):\n",
    "        data_length = len(datasets)\n",
    "        label_count = {}\n",
    "        for i in range(data_length):\n",
    "            label = datasets[i][-1]\n",
    "            if label not in label_count:\n",
    "                label_count[label] = 0\n",
    "            label_count[label] += 1\n",
    "        ent = -sum([(p / data_length) * log(p / data_length, 2)\n",
    "                    for p in label_count.values()])\n",
    "        return ent\n",
    "\n",
    "    # 经验条件熵\n",
    "    def cond_ent(self, datasets, axis=0):\n",
    "        data_length = len(datasets)\n",
    "        feature_sets = {}\n",
    "        for i in range(data_length):\n",
    "            feature = datasets[i][axis]\n",
    "            if feature not in feature_sets:\n",
    "                feature_sets[feature] = []\n",
    "            feature_sets[feature].append(datasets[i])\n",
    "        cond_ent = sum([(len(p) / data_length) * self.calc_ent(p)\n",
    "                        for p in feature_sets.values()])\n",
    "        return cond_ent\n",
    "\n",
    "    # 信息增益\n",
    "    @staticmethod\n",
    "    def info_gain(ent, cond_ent):\n",
    "        return ent - cond_ent\n",
    "\n",
    "    def info_gain_train(self, datasets):\n",
    "        count = len(datasets[0]) - 1\n",
    "        ent = self.calc_ent(datasets)\n",
    "        best_feature = []\n",
    "        for c in range(count):\n",
    "            c_info_gain = self.info_gain(ent, self.cond_ent(datasets, axis=c))\n",
    "            best_feature.append((c, c_info_gain))\n",
    "        # 比较大小\n",
    "        best_ = max(best_feature, key=lambda x: x[-1])\n",
    "        return best_\n",
    "\n",
    "    def train(self, train_data):\n",
    "        \"\"\"\n",
    "        input:数据集D(DataFrame格式)，特征集A，阈值eta\n",
    "        output:决策树T\n",
    "        \"\"\"\n",
    "        _, y_train, features = train_data.iloc[:, :\n",
    "                                               -1], train_data.iloc[:,\n",
    "                                                                    -1], train_data.columns[:\n",
    "                                                                                            -1]\n",
    "        # 1,若D中实例属于同一类Ck，则T为单节点树，并将类Ck作为结点的类标记，返回T\n",
    "        if len(y_train.value_counts()) == 1:\n",
    "            return Node(root=True, label=y_train.iloc[0])\n",
    "\n",
    "        # 2, 若A为空，则T为单节点树，将D中实例树最大的类Ck作为该节点的类标记，返回T\n",
    "        if len(features) == 0:\n",
    "            return Node(\n",
    "                root=True,\n",
    "                label=y_train.value_counts().sort_values(\n",
    "                    ascending=False).index[0])\n",
    "\n",
    "        # 3,计算最大信息增益 同5.1,Ag为信息增益最大的特征\n",
    "        max_feature, max_info_gain = self.info_gain_train(np.array(train_data))\n",
    "        max_feature_name = features[max_feature]\n",
    "\n",
    "        # 4,Ag的信息增益小于阈值eta,则置T为单节点树，并将D中是实例数最大的类Ck作为该节点的类标记，返回T\n",
    "        if max_info_gain < self.epsilon:\n",
    "            return Node(\n",
    "                root=True,\n",
    "                label=y_train.value_counts().sort_values(\n",
    "                    ascending=False).index[0])\n",
    "\n",
    "        # 5,构建Ag子集\n",
    "        node_tree = Node(\n",
    "            root=False, feature_name=max_feature_name, feature=max_feature)\n",
    "\n",
    "        feature_list = train_data[max_feature_name].value_counts().index\n",
    "        for f in feature_list:\n",
    "            sub_train_df = train_data.loc[train_data[max_feature_name] ==\n",
    "                                          f].drop([max_feature_name], axis=1)\n",
    "\n",
    "            # 6, 递归生成树\n",
    "            sub_tree = self.train(sub_train_df)\n",
    "            node_tree.add_node(f, sub_tree)\n",
    "\n",
    "        # pprint.pprint(node_tree.tree)\n",
    "        return node_tree\n",
    "\n",
    "    def fit(self, train_data):\n",
    "        self._tree = self.train(train_data)\n",
    "        return self._tree\n",
    "\n",
    "    def predict(self, X_test):\n",
    "        return self._tree.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets, labels = create_data()\n",
    "data_df = pd.DataFrame(datasets, columns=labels)\n",
    "dt = DTree()\n",
    "tree = dt.fit(data_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'label:': None, 'feature': 2, 'tree': {'否': {'label:': None, 'feature': 1, 'tree': {'否': {'label:': '否', 'feature': None, 'tree': {}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'否'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.predict(['老年', '否', '否', '一般'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scikit-learn实例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用Iris数据集，我们可以构建如下树："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data\n",
    "def create_data():\n",
    "    iris = load_iris()       \n",
    "    df = pd.DataFrame(iris.data, columns=iris.feature_names)\n",
    "    df['label'] = iris.target\n",
    "    df.columns = [\n",
    "        'sepal length', 'sepal width', 'petal length', 'petal width', 'label'\n",
    "    ]\n",
    "    data = np.array(df.iloc[:100, [0, 1, -1]])\n",
    "    # print(data)\n",
    "    return data[:, :2], data[:, -1],iris.feature_names[0:2]\n",
    "\n",
    "\n",
    "X, y,feature_name= create_data()\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9333333333333333"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.tree import export_graphviz\n",
    "import graphviz\n",
    "from sklearn import tree\n",
    "\n",
    "clf = DecisionTreeClassifier()\n",
    "clf.fit(X_train, y_train,)\n",
    "\n",
    "clf.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一旦经过训练，就可以用 plot_tree函数绘制树："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0.5, 0.9, 'x[0] <= 5.45\\ngini = 0.498\\nsamples = 70\\nvalue = [33, 37]'),\n",
       " Text(0.25, 0.7, 'x[1] <= 2.8\\ngini = 0.272\\nsamples = 37\\nvalue = [31, 6]'),\n",
       " Text(0.125, 0.5, 'gini = 0.0\\nsamples = 5\\nvalue = [0, 5]'),\n",
       " Text(0.375, 0.5, 'x[0] <= 5.35\\ngini = 0.061\\nsamples = 32\\nvalue = [31, 1]'),\n",
       " Text(0.25, 0.3, 'gini = 0.0\\nsamples = 27\\nvalue = [27, 0]'),\n",
       " Text(0.5, 0.3, 'x[1] <= 3.2\\ngini = 0.32\\nsamples = 5\\nvalue = [4, 1]'),\n",
       " Text(0.375, 0.1, 'gini = 0.0\\nsamples = 1\\nvalue = [0, 1]'),\n",
       " Text(0.625, 0.1, 'gini = 0.0\\nsamples = 4\\nvalue = [4, 0]'),\n",
       " Text(0.75, 0.7, 'x[1] <= 3.6\\ngini = 0.114\\nsamples = 33\\nvalue = [2, 31]'),\n",
       " Text(0.625, 0.5, 'gini = 0.0\\nsamples = 31\\nvalue = [0, 31]'),\n",
       " Text(0.875, 0.5, 'gini = 0.0\\nsamples = 2\\nvalue = [2, 0]')]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tree.plot_tree(clf) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以导出树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "tree_pic = export_graphviz(clf, out_file=\"mytree.pdf\")\n",
    "with open('mytree.pdf') as f:\n",
    "    dot_graph = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 12.2.1 (20241206.2353)\n",
       " -->\n",
       "<!-- Title: Tree Pages: 1 -->\n",
       "<svg width=\"454pt\" height=\"491pt\"\n",
       " viewBox=\"0.00 0.00 454.00 491.25\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 487.25)\">\n",
       "<title>Tree</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-487.25 450,-487.25 450,4 -4,4\"/>\n",
       "<!-- 0 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>0</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"277.5,-483.25 168.5,-483.25 168.5,-412.25 277.5,-412.25 277.5,-483.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-465.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[0] &lt;= 5.45</text>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-450.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.498</text>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-434.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 70</text>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-418.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [33, 37]</text>\n",
       "</g>\n",
       "<!-- 1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>1</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"213.75,-376.25 112.25,-376.25 112.25,-305.25 213.75,-305.25 213.75,-376.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-358.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 2.8</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-343.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.272</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-327.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 37</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-311.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [31, 6]</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;1 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>0&#45;&gt;1</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M203.02,-411.79C198.37,-403.64 193.35,-394.86 188.49,-386.36\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"191.64,-384.82 183.64,-377.87 185.57,-388.29 191.64,-384.82\"/>\n",
       "<text text-anchor=\"middle\" x=\"176.31\" y=\"-395.25\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">True</text>\n",
       "</g>\n",
       "<!-- 8 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>8</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"333.75,-376.25 232.25,-376.25 232.25,-305.25 333.75,-305.25 333.75,-376.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-358.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 3.6</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-343.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.114</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-327.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 33</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-311.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [2, 31]</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;8 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>0&#45;&gt;8</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M242.98,-411.79C247.63,-403.64 252.65,-394.86 257.51,-386.36\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"260.43,-388.29 262.36,-377.87 254.36,-384.82 260.43,-388.29\"/>\n",
       "<text text-anchor=\"middle\" x=\"269.69\" y=\"-395.25\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">False</text>\n",
       "</g>\n",
       "<!-- 2 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>2</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"94,-261.38 0,-261.38 0,-206.12 94,-206.12 94,-261.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-244.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-228.32\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 5</text>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-212.57\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 5]</text>\n",
       "</g>\n",
       "<!-- 1&#45;&gt;2 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>1&#45;&gt;2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M124.37,-304.79C111.74,-293.35 97.71,-280.65 85.11,-269.25\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"87.54,-266.72 77.77,-262.61 82.84,-271.91 87.54,-266.72\"/>\n",
       "</g>\n",
       "<!-- 3 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>3</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"213.75,-269.25 112.25,-269.25 112.25,-198.25 213.75,-198.25 213.75,-269.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-251.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[0] &lt;= 5.35</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-236.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.061</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-220.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 32</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-204.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [31, 1]</text>\n",
       "</g>\n",
       "<!-- 1&#45;&gt;3 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>1&#45;&gt;3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M163,-304.79C163,-297.17 163,-289 163,-281.02\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"166.5,-281.07 163,-271.07 159.5,-281.07 166.5,-281.07\"/>\n",
       "</g>\n",
       "<!-- 4 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>4</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"155.75,-154.38 54.25,-154.38 54.25,-99.12 155.75,-99.12 155.75,-154.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"105\" y=\"-137.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"105\" y=\"-121.33\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 27</text>\n",
       "<text text-anchor=\"middle\" x=\"105\" y=\"-105.58\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [27, 0]</text>\n",
       "</g>\n",
       "<!-- 3&#45;&gt;4 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>3&#45;&gt;4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M143.69,-197.79C137.79,-187.12 131.3,-175.36 125.34,-164.57\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"128.46,-162.98 120.56,-155.91 122.33,-166.36 128.46,-162.98\"/>\n",
       "</g>\n",
       "<!-- 5 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>5</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"268,-162.25 174,-162.25 174,-91.25 268,-91.25 268,-162.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-144.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 3.2</text>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-129.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.32</text>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-113.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 5</text>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-97.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [4, 1]</text>\n",
       "</g>\n",
       "<!-- 3&#45;&gt;5 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>3&#45;&gt;5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M182.31,-197.79C186.76,-189.73 191.56,-181.05 196.21,-172.63\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"199.27,-174.33 201.04,-163.89 193.14,-170.95 199.27,-174.33\"/>\n",
       "</g>\n",
       "<!-- 6 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>6</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"212,-55.25 118,-55.25 118,0 212,0 212,-55.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"165\" y=\"-37.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"165\" y=\"-22.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 1</text>\n",
       "<text text-anchor=\"middle\" x=\"165\" y=\"-6.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 1]</text>\n",
       "</g>\n",
       "<!-- 5&#45;&gt;6 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>5&#45;&gt;6</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M200.94,-90.96C196.17,-82.68 191.06,-73.81 186.23,-65.45\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"189.31,-63.78 181.28,-56.87 183.25,-67.28 189.31,-63.78\"/>\n",
       "</g>\n",
       "<!-- 7 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>7</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"324,-55.25 230,-55.25 230,0 324,0 324,-55.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"277\" y=\"-37.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"277\" y=\"-22.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 4</text>\n",
       "<text text-anchor=\"middle\" x=\"277\" y=\"-6.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [4, 0]</text>\n",
       "</g>\n",
       "<!-- 5&#45;&gt;7 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>5&#45;&gt;7</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M241.06,-90.96C245.83,-82.68 250.94,-73.81 255.77,-65.45\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"258.75,-67.28 260.72,-56.87 252.69,-63.78 258.75,-67.28\"/>\n",
       "</g>\n",
       "<!-- 9 -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>9</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"333.75,-261.38 232.25,-261.38 232.25,-206.12 333.75,-206.12 333.75,-261.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-244.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-228.32\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 31</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-212.57\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 31]</text>\n",
       "</g>\n",
       "<!-- 8&#45;&gt;9 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>8&#45;&gt;9</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M283,-304.79C283,-294.56 283,-283.32 283,-272.91\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"286.5,-273.1 283,-263.1 279.5,-273.1 286.5,-273.1\"/>\n",
       "</g>\n",
       "<!-- 10 -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>10</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"446,-261.38 352,-261.38 352,-206.12 446,-206.12 446,-261.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"399\" y=\"-244.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"399\" y=\"-228.32\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 2</text>\n",
       "<text text-anchor=\"middle\" x=\"399\" y=\"-212.57\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [2, 0]</text>\n",
       "</g>\n",
       "<!-- 8&#45;&gt;10 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>8&#45;&gt;10</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M321.63,-304.79C334.26,-293.35 348.29,-280.65 360.89,-269.25\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"363.16,-271.91 368.23,-262.61 358.46,-266.72 363.16,-271.91\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.sources.Source at 0x1e3c0520990>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "graphviz.Source(dot_graph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树回归"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a random dataset\n",
    "rng = np.random.RandomState(1)\n",
    "X = np.sort(5 * rng.rand(80, 1), axis=0)\n",
    "y = np.sin(X).ravel()\n",
    "y[::5] += 3 * (0.5 - rng.rand(16))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Fit regression model\n",
    "regr_1 = DecisionTreeRegressor(max_depth=2)\n",
    "regr_2 = DecisionTreeRegressor(max_depth=5)\n",
    "regr_1.fit(X, y)\n",
    "regr_2.fit(X, y)\n",
    "\n",
    "# Predict\n",
    "X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]\n",
    "y_1 = regr_1.predict(X_test)\n",
    "y_2 = regr_2.predict(X_test)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure()\n",
    "plt.scatter(X, y, s=20, edgecolor=\"black\", c=\"darkorange\", label=\"data\")\n",
    "plt.plot(X_test, y_1, color=\"cornflowerblue\", label=\"max_depth=2\", linewidth=2)\n",
    "plt.plot(X_test, y_2, color=\"yellowgreen\", label=\"max_depth=5\", linewidth=2)\n",
    "plt.xlabel(\"data\")\n",
    "plt.ylabel(\"target\")\n",
    "plt.title(\"Decision Tree Regression\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scikit-learn 的决策树参数"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "DecisionTreeClassifier(criterion=\"gini\",\n",
    "                 splitter=\"best\",\n",
    "                 max_depth=None,\n",
    "                 min_samples_split=2,\n",
    "                 min_samples_leaf=1,\n",
    "                 min_weight_fraction_leaf=0.,\n",
    "                 max_features=None,\n",
    "                 random_state=None,\n",
    "                 max_leaf_nodes=None,\n",
    "                 min_impurity_decrease=0.,\n",
    "                 min_impurity_split=None,\n",
    "                 class_weight=None,\n",
    "                 presort=False)\n",
    "\n",
    "参数含义：\n",
    "1.criterion:string, optional (default=\"gini\")\n",
    "            (1).criterion='gini',分裂节点时评价准则是Gini指数。\n",
    "            (2).criterion='entropy',分裂节点时的评价指标是信息增益。\n",
    "2.max_depth:int or None, optional (default=None)。指定树的最大深度。\n",
    "            如果为None，表示树的深度不限。直到所有的叶子节点都是纯净的，即叶子节点\n",
    "            中所有的样本点都属于同一个类别。或者每个叶子节点包含的样本数小于min_samples_split。\n",
    "3.splitter:string, optional (default=\"best\")。指定分裂节点时的策略。\n",
    "           (1).splitter='best',表示选择最优的分裂策略。\n",
    "           (2).splitter='random',表示选择最好的随机切分策略。\n",
    "4.min_samples_split:int, float, optional (default=2)。表示分裂一个内部节点需要的做少样本数。\n",
    "           (1).如果为整数，则min_samples_split就是最少样本数。\n",
    "           (2).如果为浮点数(0到1之间)，则每次分裂最少样本数为ceil(min_samples_split * n_samples)\n",
    "5.min_samples_leaf: int, float, optional (default=1)。指定每个叶子节点需要的最少样本数。\n",
    "           (1).如果为整数，则min_samples_split就是最少样本数。\n",
    "           (2).如果为浮点数(0到1之间)，则每个叶子节点最少样本数为ceil(min_samples_leaf * n_samples)\n",
    "6.min_weight_fraction_leaf:float, optional (default=0.)\n",
    "           指定叶子节点中样本的最小权重。\n",
    "7.max_features:int, float, string or None, optional (default=None).\n",
    "           搜寻最佳划分的时候考虑的特征数量。\n",
    "           (1).如果为整数，每次分裂只考虑max_features个特征。\n",
    "           (2).如果为浮点数(0到1之间)，每次切分只考虑int(max_features * n_features)个特征。\n",
    "           (3).如果为'auto'或者'sqrt',则每次切分只考虑sqrt(n_features)个特征\n",
    "           (4).如果为'log2',则每次切分只考虑log2(n_features)个特征。\n",
    "           (5).如果为None,则每次切分考虑n_features个特征。\n",
    "           (6).如果已经考虑了max_features个特征，但还是没有找到一个有效的切分，那么还会继续寻找\n",
    "           下一个特征，直到找到一个有效的切分为止。\n",
    "8.random_state:int, RandomState instance or None, optional (default=None)\n",
    "           (1).如果为整数，则它指定了随机数生成器的种子。\n",
    "           (2).如果为RandomState实例，则指定了随机数生成器。\n",
    "           (3).如果为None，则使用默认的随机数生成器。\n",
    "9.max_leaf_nodes: int or None, optional (default=None)。指定了叶子节点的最大数量。\n",
    "           (1).如果为None,叶子节点数量不限。\n",
    "           (2).如果为整数，则max_depth被忽略。\n",
    "10.min_impurity_decrease:float, optional (default=0.)\n",
    "         如果节点的分裂导致不纯度的减少(分裂后样本比分裂前更加纯净)大于或等于min_impurity_decrease，则分裂该节点。\n",
    "         加权不纯度的减少量计算公式为：\n",
    "         min_impurity_decrease=N_t / N * (impurity - N_t_R / N_t * right_impurity\n",
    "                            - N_t_L / N_t * left_impurity)\n",
    "         其中N是样本的总数，N_t是当前节点的样本数，N_t_L是分裂后左子节点的样本数，\n",
    "         N_t_R是分裂后右子节点的样本数。impurity指当前节点的基尼指数，right_impurity指\n",
    "         分裂后右子节点的基尼指数。left_impurity指分裂后左子节点的基尼指数。\n",
    "11.min_impurity_split:float\n",
    "         树生长过程中早停止的阈值。如果当前节点的不纯度高于阈值，节点将分裂，否则它是叶子节点。\n",
    "         这个参数已经被弃用。用min_impurity_decrease代替了min_impurity_split。\n",
    "12.class_weight:dict, list of dicts, \"balanced\" or None, default=None\n",
    "         类别权重的形式为{class_label: weight}\n",
    "         (1).如果没有给出每个类别的权重，则每个类别的权重都为1。\n",
    "         (2).如果class_weight='balanced'，则分类的权重与样本中每个类别出现的频率成反比。\n",
    "         计算公式为：n_samples / (n_classes * np.bincount(y))\n",
    "         (3).如果sample_weight提供了样本权重(由fit方法提供)，则这些权重都会乘以sample_weight。\n",
    "13.presort:bool, optional (default=False)\n",
    "        指定是否需要提前排序数据从而加速训练中寻找最优切分的过程。设置为True时，对于大数据集\n",
    "        会减慢总体的训练过程；但是对于一个小数据集或者设定了最大深度的情况下，会加速训练过程。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树调参"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入库\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn import datasets\n",
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150, 4) (150,)\n"
     ]
    }
   ],
   "source": [
    "# 导入数据集\n",
    "X = datasets.load_iris()  # 以全部字典形式返回,有data,target,target_names三个键\n",
    "data = X.data\n",
    "target = X.target\n",
    "name = X.target_names\n",
    "x, y = datasets.load_iris(return_X_y=True)  # 能一次性取前2个\n",
    "print(x.shape, y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 数据分为训练集和测试集\n",
    "x_train, x_test, y_train, y_test = train_test_split(x,\n",
    "                                                    y,\n",
    "                                                    test_size=0.2,\n",
    "                                                    random_state=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最优分类器: {'criterion': 'gini', 'max_depth': 30, 'min_impurity_decrease': 0.2, 'min_samples_leaf': 3} 最优分数: 0.9416666666666665\n"
     ]
    }
   ],
   "source": [
    "# 用GridSearchCV寻找最优参数（字典）\n",
    "param = {\n",
    "    'criterion': ['gini'],\n",
    "    'max_depth': [30, 50, 60, 100],\n",
    "    'min_samples_leaf': [2, 3, 5, 10],\n",
    "    'min_impurity_decrease': [0.1, 0.2, 0.5]\n",
    "}\n",
    "grid = GridSearchCV(DecisionTreeClassifier(), param_grid=param, cv=6)\n",
    "grid.fit(x_train, y_train)\n",
    "print('最优分类器:', grid.best_params_, '最优分数:', grid.best_score_)  # 得到最优的参数和分值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 参考\n",
    "\n",
    "- https://github.com/fengdu78/lihang-code\n",
    "\n",
    "- 李航. 统计学习方法[M]. 北京: 清华大学出版社,2019.\n",
    "\n",
    "- https://scikit-learn.org"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
